const { User } = require('../models');
const bcrypt = require('bcryptjs');

// 保留内存中的用户存储用于兼容性
const users = new Map();
exports.users = users;

// 注册
exports.register = async (req, res) => {
  try {
    const { username, email, password, passwordConfirm } = req.body;

    // 基本验证
    if (!username || !email || !password) {
      return res.status(400).json({
        status: 'fail',
        message: '请提供用户名、邮箱和密码'
      });
    }

    // 检查是否有密码确认字段
    if (passwordConfirm && password !== passwordConfirm) {
      return res.status(400).json({
        status: 'fail',
        message: '两次密码输入不一致'
      });
    }

    // 检查邮箱是否已存在
    const existingUser = await User.findOne({ where: { email } });
    if (existingUser) {
      return res.status(400).json({
        status: 'fail',
        message: '该邮箱已被注册'
      });
    }

    // 创建新用户（使用数据库）
    const newUser = await User.create({
      username,
      email,
      password, // 密码会在User模型的beforeCreate钩子中自动加密
      role: 'user'
    });

    // 设置会话
    req.session.userId = newUser.id;

    // 同时也保存在内存Map中（为了兼容现有代码）
    const userObj = newUser.toJSON();
    users.set(newUser.id.toString(), {
      ...userObj,
      favorites: []
    });

    // 返回用户信息（不包含密码）
    const userWithoutPassword = {
      id: newUser.id,
      username: newUser.username,
      email: newUser.email,
      role: newUser.role,
      createdAt: newUser.createdAt,
      updatedAt: newUser.updatedAt
    };

    res.status(201).json({
      status: 'success',
      data: {
        user: userWithoutPassword
      }
    });
  } catch (error) {
    console.error('注册错误:', error);
    res.status(500).json({
      status: 'error',
      message: error.message
    });
  }
};

// 登录
exports.login = async (req, res) => {
  try {
    const { email, password } = req.body;

    // 基本验证
    if (!email || !password) {
      return res.status(400).json({
        status: 'fail',
        message: '请提供邮箱和密码'
      });
    }

    // 查找用户
    const user = await User.findOne({ where: { email } });

    // 检查用户是否存在
    if (!user) {
      return res.status(401).json({
        status: 'fail',
        message: '邮箱或密码不正确'
      });
    }

    // 验证密码
    const isPasswordCorrect = await user.correctPassword(password);
    if (!isPasswordCorrect) {
      return res.status(401).json({
        status: 'fail',
        message: '邮箱或密码不正确'
      });
    }

    // 设置会话
    req.session.userId = user.id;

    // 同时也保存在内存Map中（为了兼容现有代码）
    const userObj = user.toJSON();
    users.set(user.id.toString(), {
      ...userObj,
      favorites: [] // 初始化空收藏列表，实际应该从数据库中加载
    });

    // 返回用户信息（不包含密码）
    const userWithoutPassword = {
      id: user.id,
      username: user.username,
      email: user.email,
      role: user.role,
      createdAt: user.createdAt,
      updatedAt: user.updatedAt
    };

    res.status(200).json({
      status: 'success',
      data: {
        user: userWithoutPassword
      }
    });
  } catch (error) {
    console.error('登录错误:', error);
    res.status(500).json({
      status: 'error',
      message: error.message
    });
  }
};

// 登出
exports.logout = (req, res) => {
  req.session.destroy(err => {
    if (err) {
      return res.status(500).json({
        status: 'error',
        message: '登出失败'
      });
    }

    res.clearCookie('connect.sid');
    res.status(200).json({
      status: 'success',
      message: '成功登出'
    });
  });
};

// 保护路由中间件
exports.protect = async (req, res, next) => {
  try {
    // 检查是否已登录
    if (!req.session.userId) {
      return res.status(401).json({
        status: 'fail',
        message: '请先登录'
      });
    }

    // 查找用户（优先从内存中查找，如果不存在则从数据库加载）
    let user = users.get(req.session.userId.toString());
    
    if (!user) {
      // 从数据库中查找
      const dbUser = await User.findByPk(req.session.userId);
      
      if (!dbUser) {
        return res.status(401).json({
          status: 'fail',
          message: '用户不存在，请重新登录'
        });
      }
      
      // 将数据库用户添加到内存中
      user = dbUser.toJSON();
      user.favorites = []; // 初始化空收藏列表
      users.set(req.session.userId.toString(), user);
    }

    // 将用户添加到请求对象
    req.user = user;
    next();
  } catch (error) {
    console.error('保护中间件错误:', error);
    res.status(500).json({
      status: 'error',
      message: '内部服务器错误'
    });
  }
};

// 限制角色访问中间件
exports.restrictTo = (...roles) => {
  return (req, res, next) => {
    if (!roles.includes(req.user.role)) {
      return res.status(403).json({
        status: 'fail',
        message: '您没有权限执行此操作'
      });
    }
    next();
  };
}; 